var O = AjaxStack.ObjectExt;

YAHOO.namespace("ajaxstack");
YAHOO.ajaxstack.ArrayExt = new YAHOO.tool.TestCase({

	name: "ObjectExt Tests",

	//--------------------------------------------- 
	// Setup and tear down 
	//---------------------------------------------

	setUp: function()
	{
	},

	tearDown: function()
	{
	},

	//--------------------------------------------- 
	// Tests 
	//---------------------------------------------

	testKeys: function()
	{
		ArrayAssert.itemsAreEqual(['a', 'b', 'c'], O.keys({ a: 1, b: 2, c: 3 }));
	},

	testValues: function()
	{
		ArrayAssert.itemsAreEqual([1, 2, 3], O.values({ a: 1, b: 2, c: 3 }));
	},

	testContainsKey: function()
	{
		Assert.isTrue (O.containsKey({ a: 'b' }, 'a'));
		Assert.isFalse(O.containsKey({ a: 'b' }, 'b'));
		Assert.isTrue (O.containsKey({ a: 'b', c: 'd', e: 'f' }, 'a'));
		Assert.isFalse(O.containsKey({ a: 'b', c: 'd', e: 'f' }, 'b'));
		Assert.isFalse(O.containsKey({ a: 'b', c: 'd', e: 'f' }, ''));
	},

	testContainsValue: function()
	{
		Assert.isTrue (O.containsValue({ a: 'b' }, 'b'));
		Assert.isFalse(O.containsValue({ a: 'b' }, 'a'));
		Assert.isTrue (O.containsValue({ a: 'b', c: 'd', e: 'f' }, 'd'));
		Assert.isFalse(O.containsValue({ a: 'b', c: 'd', e: 'f' }, 'B'));
		Assert.isFalse(O.containsValue({ a: 'b', c: 'd', e: 'f' }, ''));
	},

	testAny: function()
	{
		Assert.isTrue (O.any({ a: 'b', c: 'd', e: 'f' }, function(k, v) { return k < v; }));
		Assert.isFalse(O.any({ a: 'b', c: 'd', e: 'f' }, function(k, v) { return k > v; }));
		Assert.isTrue (O.any({ a: 'b', c: 'd', e: 'f' }, function(k, v) { return v == 'b'; }));
		Assert.isFalse(O.any({ a: 'b', c: 'd', e: 'f' }, function(k, v) { return k == v; }));
		Assert.isTrue (O.any({ a: 'b', c: 'd', e: 'e' }, function(k, v) { return k == v; }));
	},

	testAll: function()
	{
		Assert.isTrue (O.all({ a: 'b', c: 'd', e: 'f' }, function(k, v) { return k < v; }));
		Assert.isFalse(O.all({ a: 'b', c: 'd', e: 'f' }, function(k, v) { return k > v; }));
		Assert.isFalse(O.all({ a: 'b', c: 'd', e: 'f' }, function(k, v) { return k == 'b'; }));
		Assert.isFalse(O.all({ a: 'b', c: 'd', e: 'f' }, function(k, v) { return k == v; }));
		Assert.isTrue (O.all({ a: 'b', c: 'd', e: 'f' }, function(k, v) { return k != v; }));
		Assert.isFalse(O.all({ a: 'b', c: 'd', e: 'e' }, function(k, v) { return k == v; }));
	},

	testIsEmpty: function()
	{
		Assert.isTrue(O.isEmpty(null));
		Assert.isTrue(O.isEmpty({}));
		Assert.isFalse(A.isEmpty({ a: 1 }));
	},

	testEach: function()
	{
		var sum = 0;
		O.each({ a: 1, b: 2, c: 3 }, function(k, v) { sum += v; });
		Assert.areEqual(1 + 2 + 3, sum);

		var str = "";
		O.each({ a: 1, b: 2, c: 3 }, function(k, v) { str += k + "=" + v; });
		Assert.areEqual("a=1b=2c=3", str);
	},

	testMerge: function()
	{
		var arr1 = { a: 1, b: 2 }, arr2 = { c: 3, d: 4 };
		O.merge(arr1, arr2);
		ObjectAssert.propertiesAreEqual({ a: 1, b: 2, c: 3, d: 4 }, arr1);
	},

	testClone: function()
	{
		var obj1 = { a: 1, b: 2, c: 3 };
		var obj2 = O.clone(obj1);
		ObjectAssert.propertiesAreEqual({ a: 1, b: 2, c: 3 }, obj1);
		ObjectAssert.propertiesAreEqual({ a: 1, b: 2, c: 3 }, obj2);

		obj2['d'] = 4;
		ArrayAssert.itemsAreEqual({ a: 1, b: 2, c: 3 }, obj1);
		ArrayAssert.itemsAreEqual({ a: 1, b: 2, c: 3, d: 4 }, obj2);
	}

});

